home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / win / vb / inpgrid.exe / UTIL.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-19  |  28.3 KB  |  795 lines
  1. //---------------------------------------------------------------------------
  2. // Util.c
  3. //---------------------------------------------------------------------------
  4. // Griglia Control
  5. //---------------------------------------------------------------------------
  6.  
  7. #define NOCOMM
  8.  
  9. #include <windows.h>
  10. #include <string.h>
  11. #include <ctype.h>
  12. #include "vbapi.h"
  13. #include "griglia.h"
  14.  
  15. //--------------------------------------------------------------------------
  16. // CellLRRect
  17. //---------------------------------------------------------------------------
  18. BOOL CellLRRect (PGRIGLIA lpGrigliaStruct,
  19.                  UINT     nCol,
  20.                  LPRECT   lpRect) {
  21.  
  22.             LONG  lScroll, lTemp;    
  23.     static  RECT  rStatic;
  24.  
  25.     // Get Client Rect
  26.     GetClientRect (lpGrigliaStruct->hWndStatic,    (LPRECT)&rStatic);
  27.  
  28.     // find right position of cursor cell    
  29.     lScroll = Griglia_HorPos (nCol, lpGrigliaStruct);
  30.     if (lScroll != INVALID_POS) {
  31.         
  32.         lTemp = PUSH_H_GRID + lScroll -        
  33.                 lpGrigliaStruct->xChar / (2 * INTERCOLUMN_FACTOR);
  34.         if (lTemp > MAKELONG (rStatic.right, 0))
  35.             lpRect->right = rStatic.right;
  36.         else if (lTemp < MAKELONG (rStatic.left, 0))
  37.             lpRect->right = rStatic.left;
  38.         else    
  39.             lpRect->right = LOWORD (lTemp);
  40.  
  41.         // find left position of cursor cell        
  42.         if (nCol) {            
  43.             
  44.             lScroll = Griglia_HorPos (nCol - 1,            
  45.                                       lpGrigliaStruct);                                    
  46.             if (lScroll != INVALID_POS) {
  47.                 lTemp = PUSH_H_GRID + lScroll -                
  48.                         lpGrigliaStruct->xChar / (2 * INTERCOLUMN_FACTOR);
  49.                 if (lTemp > MAKELONG (rStatic.right, 0))
  50.                     lpRect->left = rStatic.right;
  51.                 else if (lTemp < MAKELONG (rStatic.left, 0))
  52.                     lpRect->left = rStatic.left;
  53.                 else    
  54.                     lpRect->left = LOWORD (lTemp);
  55.                 return (TRUE);
  56.             }
  57.             
  58.         } else {
  59.     
  60.             lpRect->left = PUSH_H_GRID;        
  61.             return (TRUE);
  62.         }                        
  63.     
  64.     }
  65.     return (FALSE);            
  66. }                
  67.  
  68. //--------------------------------------------------------------------------
  69. // CellTBRect
  70. //---------------------------------------------------------------------------
  71. BOOL CellTBRect (PGRIGLIA lpGrigliaStruct,
  72.                  UINT     nRow,
  73.                  LPRECT   lpRect) {
  74.                 
  75.            LONG  lScroll, lTemp;    
  76.     static RECT  rStatic;
  77.  
  78.     // Get Client Rect
  79.     GetClientRect (lpGrigliaStruct->hWndStatic,    (LPRECT)&rStatic);
  80.  
  81.     // find bottom position of cursor cell        
  82.     lScroll = Griglia_VertPos (nRow,
  83.                                 lpGrigliaStruct);
  84.     if (lScroll != INVALID_POS) {
  85.         
  86.         lTemp = PUSH_V_GRID + lScroll -
  87.                 lpGrigliaStruct->yChar / (2 * INTERCOLUMN_FACTOR);
  88.         if (lTemp > MAKELONG (rStatic.bottom, 0))
  89.             lpRect->bottom = rStatic.bottom;
  90.         else if (lTemp < MAKELONG (rStatic.top, 0))
  91.             lpRect->bottom = rStatic.top;
  92.         else
  93.             lpRect->bottom = LOWORD (lTemp);
  94.     
  95.         // find top position of cursor cell
  96.         if (nRow > 0) {
  97.             lScroll = Griglia_VertPos (nRow - 1,
  98.                                        lpGrigliaStruct);
  99.             if (lScroll != INVALID_POS) {
  100.                 lTemp  = PUSH_V_GRID + lScroll -
  101.                          lpGrigliaStruct->yChar / (2 * INTERCOLUMN_FACTOR);
  102.                 if (lTemp > MAKELONG (rStatic.bottom, 0))
  103.                     lpRect->top = rStatic.bottom;
  104.                 else if (lTemp < MAKELONG (rStatic.top, 0))
  105.                     lpRect->top = rStatic.top;
  106.                 else
  107.                     lpRect->top = LOWORD (lTemp);
  108.                 return (TRUE);
  109.             }
  110.         
  111.         } else {
  112.     
  113.             lpRect->top = PUSH_V_GRID;
  114.             return (TRUE);    
  115.         }
  116.     }
  117.     return (FALSE);    
  118. }
  119.  
  120. //--------------------------------------------------------------------------
  121. // CellRect
  122. //---------------------------------------------------------------------------
  123. BOOL CellRect (PGRIGLIA lpGrigliaStruct,
  124.                UINT     nCol,
  125.                UINT     nRow,
  126.                LPRECT   lpRect) {
  127.  
  128.     SetRectEmpty (lpRect);
  129.     
  130.     if (CellLRRect (lpGrigliaStruct,
  131.                     nCol,
  132.                     lpRect))    
  133.         return (CellTBRect (lpGrigliaStruct,
  134.                             nRow,
  135.                             lpRect));
  136.     return (FALSE);                        
  137.  
  138. }
  139. //--------------------------------------------------------------------------
  140. // BlockLRRect
  141. //---------------------------------------------------------------------------
  142. BOOL BlockLRRect (PGRIGLIA lpGrigliaStruct,
  143.                   UINT     nStartCol,
  144.                   UINT     nEndCol,
  145.                   LPRECT   lpRect) {
  146.  
  147.            LONG  lScroll, lTemp;    
  148.     static RECT  rStatic;
  149.  
  150.     // Get Client Rect
  151.     GetClientRect (lpGrigliaStruct->hWndStatic,    (LPRECT)&rStatic);
  152.  
  153.     // find right position of cursor cell    
  154.     lScroll = Griglia_HorPos (nEndCol, lpGrigliaStruct);
  155.     if (lScroll != INVALID_POS) {
  156.         
  157.         lTemp = PUSH_H_GRID + lScroll -        
  158.                 lpGrigliaStruct->xChar / (2 * INTERCOLUMN_FACTOR);
  159.         if (lTemp > MAKELONG (rStatic.right, 0))
  160.             lpRect->right = rStatic.right;
  161.         else if (lTemp < MAKELONG (rStatic.left, 0))
  162.             lpRect->right = rStatic.left;
  163.         else    
  164.             lpRect->right = LOWORD (lTemp);
  165.  
  166.         // find left position of cursor cell        
  167.         if (nStartCol > 0) {
  168.             
  169.             lScroll = Griglia_HorPos (nStartCol - 1,            
  170.                                     lpGrigliaStruct);                                    
  171.             if (lScroll != INVALID_POS) {
  172.                 lTemp = PUSH_H_GRID + lScroll -                
  173.                         lpGrigliaStruct->xChar / (2 * INTERCOLUMN_FACTOR);
  174.                 if (lTemp > MAKELONG (rStatic.right, 0))
  175.                     lpRect->left = rStatic.right;
  176.                 else if (lTemp < MAKELONG (rStatic.left, 0))
  177.                     lpRect->left = rStatic.left;
  178.                 else    
  179.                     lpRect->left = LOWORD (lTemp);
  180.                 return (TRUE);
  181.             }    
  182.         
  183.         } else {
  184.     
  185.             lpRect->left = PUSH_H_GRID;        
  186.             return (TRUE);
  187.     
  188.         }
  189.         
  190.     }
  191.     return (FALSE);            
  192. }                
  193.  
  194. //--------------------------------------------------------------------------
  195. // BlockTBRect
  196. //---------------------------------------------------------------------------
  197. BOOL BlockTBRect (PGRIGLIA lpGrigliaStruct,
  198.                   UINT     nStartRow,
  199.                   UINT     nEndRow,
  200.                   LPRECT   lpRect) {
  201.                 
  202.            LONG  lScroll, lTemp;    
  203.     static RECT  rStatic;
  204.  
  205.     // Get Client Rect
  206.     GetClientRect (lpGrigliaStruct->hWndStatic,    (LPRECT)&rStatic);
  207.  
  208.     // find bottom position of cursor cell        
  209.     lScroll = Griglia_VertPos (nEndRow,
  210.                                lpGrigliaStruct);
  211.     if (lScroll != INVALID_POS) {
  212.     
  213.         lTemp = PUSH_V_GRID + lScroll -
  214.                 lpGrigliaStruct->yChar / (2 * INTERCOLUMN_FACTOR);
  215.         if (lTemp > MAKELONG (rStatic.bottom, 0))
  216.             lpRect->bottom = rStatic.bottom;
  217.         else if (lTemp < MAKELONG (rStatic.top, 0))
  218.             lpRect->bottom = rStatic.top;    
  219.         else
  220.             lpRect->bottom = LOWORD (lTemp);
  221.     
  222.         // find top position of cursor cell
  223.         if (nStartRow > 0) {
  224.             
  225.             lScroll = Griglia_VertPos (nStartRow - 1,
  226.                                        lpGrigliaStruct);
  227.             if (lScroll != INVALID_POS) {
  228.                 lTemp  = PUSH_V_GRID + lScroll -
  229.                         lpGrigliaStruct->yChar / (2 * INTERCOLUMN_FACTOR);
  230.                 if (lTemp > MAKELONG (rStatic.bottom, 0))
  231.                     lpRect->top = rStatic.bottom;
  232.                 else if (lTemp < MAKELONG (rStatic.top, 0))
  233.                     lpRect->top = rStatic.top;
  234.                 else
  235.                     lpRect->top = LOWORD (lTemp);
  236.                 return (TRUE);
  237.             }   
  238.         
  239.         } else {
  240.     
  241.             lpRect->top = PUSH_V_GRID;
  242.             return (TRUE);    
  243.         
  244.     
  245.         }
  246.     }
  247.     return (FALSE);    
  248. }
  249.  
  250. //--------------------------------------------------------------------------
  251. // BlockRect
  252. //---------------------------------------------------------------------------
  253. BOOL BlockRect (PGRIGLIA lpGrigliaStruct,
  254.                 UINT     nStartCol,
  255.                 UINT     nEndCol,
  256.                 UINT     nStartRow,
  257.                 UINT     nEndRow,
  258.                 LPRECT   lpRect) {
  259.     
  260.     UINT nTemp;
  261.     
  262.     SetRectEmpty (lpRect);
  263.     
  264.     if (nStartCol > nEndCol) {
  265.         nTemp     = nStartCol;
  266.         nEndCol   = nStartCol;                           
  267.         nStartCol = nTemp;
  268.     }    
  269.     if (nStartRow > nEndRow) {
  270.         nTemp     = nStartRow;
  271.         nEndRow   = nStartRow;                           
  272.         nStartRow = nTemp;
  273.     }    
  274.     
  275.     if (BlockLRRect (lpGrigliaStruct,
  276.                      nStartCol,
  277.                      nEndCol,
  278.                      lpRect))    
  279.         return (BlockTBRect (lpGrigliaStruct,
  280.                              nStartRow,
  281.                              nEndRow,
  282.                              lpRect));
  283.     return (FALSE);                        
  284.  
  285. }
  286.  
  287. //---------------------------------------------------------------------------
  288. // FindCell
  289. //---------------------------------------------------------------------------
  290. BOOL FindCell (PGRIGLIA lpGrigliaStruct,
  291.                LPPOINT  lpOut,    
  292.                POINT    pPoint) {                         
  293.                                 
  294.            UINT n, m;            
  295.     static RECT rRect;
  296.     
  297.     // Scan Other Columns
  298.     for (n = (lpGrigliaStruct->wFixedCols + lpGrigliaStruct->nHScrollPos);
  299.          n < lpGrigliaStruct->wCols; 
  300.          ++n) {
  301.         
  302.         if (
  303.             (CellLRRect (lpGrigliaStruct, n, (LPRECT)&rRect)) &&
  304.             (rRect.left   <= pPoint.x)                        &&                                  
  305.             (rRect.right  >= pPoint.x) 
  306.            ) {
  307.             for (m = (lpGrigliaStruct->wFixedRows + lpGrigliaStruct->nVScrollPos);                                
  308.                  m < lpGrigliaStruct->wRows; 
  309.                  ++m) {                           
  310.             
  311.                 if (
  312.                     (CellTBRect (lpGrigliaStruct, m, (LPRECT)&rRect)) &&
  313.                     (rRect.top    <= pPoint.y)                        &&   
  314.                     (rRect.bottom >= pPoint.y)                          
  315.                    ) {
  316.                     lpOut->x = n;
  317.                     lpOut->y = m;
  318.                     return (TRUE);                            
  319.                 }
  320.             }    
  321.         }    
  322.     }
  323.     return (FALSE);
  324. }
  325.  
  326. //---------------------------------------------------------------------------
  327. // KeyUp
  328. //---------------------------------------------------------------------------
  329. void KeyUp (HCTL   hctl,
  330.             HWND   hWnd,
  331.             WORD   wp) {
  332.  
  333.     WORD        wOldRow, wOldCol;
  334.     PGRIGLIA    lpGrigliaStruct = GRIGLIADEREF(hctl);
  335.  
  336.     wOldRow = lpGrigliaStruct->wCursorRow;
  337.     wOldCol = lpGrigliaStruct->wCursorCol;
  338.  
  339.     switch (wp) {
  340.  
  341.         case VK_PRIOR:
  342.             if (MoveCursorPrior (lpGrigliaStruct, bCtrlPressed)) {
  343.                 FireChangeEvent (hctl, wOldRow, wOldCol, NULL);
  344.  
  345.                 if (lpGrigliaStruct->wEnableEdit == ERASE_FLAG)
  346.                     DisplayPosition (lpGrigliaStruct);
  347.             }
  348.             break;
  349.  
  350.         case VK_NEXT:
  351.             if (MoveCursorNext (lpGrigliaStruct, bCtrlPressed)) {
  352.                 FireChangeEvent (hctl, wOldRow, wOldCol, NULL);
  353.  
  354.                 if (lpGrigliaStruct->wEnableEdit == ERASE_FLAG)
  355.                     DisplayPosition (lpGrigliaStruct);
  356.             }
  357.             break;
  358.  
  359.         case VK_HOME:
  360.             if (MoveCursorHome (lpGrigliaStruct, bCtrlPressed)) {
  361.                 FireChangeEvent (hctl, wOldRow, wOldCol, NULL);
  362.  
  363.                 if (lpGrigliaStruct->wEnableEdit == ERASE_FLAG)
  364.                     DisplayPosition (lpGrigliaStruct);
  365.             }
  366.             break;
  367.  
  368.         case VK_END:
  369.             if (MoveCursorEnd (lpGrigliaStruct, bCtrlPressed)) {
  370.                 FireChangeEvent (hctl, wOldRow, wOldCol, NULL);
  371.  
  372.                 if (lpGrigliaStruct->wEnableEdit == ERASE_FLAG)
  373.                     DisplayPosition (lpGrigliaStruct);
  374.             }
  375.             break;
  376.  
  377.         case VK_LEFT:
  378.             if (MoveCursorLeft (lpGrigliaStruct)) {
  379.                 FireChangeEvent (hctl, wOldRow, wOldCol, NULL);
  380.  
  381.                 if (lpGrigliaStruct->wEnableEdit == ERASE_FLAG)
  382.                     DisplayPosition (lpGrigliaStruct);
  383.             }
  384.             break;
  385.  
  386.         case VK_RIGHT:
  387.             if (MoveCursorRight (lpGrigliaStruct)) {
  388.                 FireChangeEvent (hctl, wOldRow, wOldCol, NULL);
  389.  
  390.                 if (lpGrigliaStruct->wEnableEdit == ERASE_FLAG)
  391.                     DisplayPosition (lpGrigliaStruct);
  392.             }
  393.             break;
  394.  
  395.         case VK_UP:
  396.             if (MoveCursorUp (lpGrigliaStruct)) {
  397.                 FireChangeEvent (hctl, wOldRow, wOldCol, NULL);
  398.  
  399.                 if (lpGrigliaStruct->wEnableEdit == ERASE_FLAG)
  400.                     DisplayPosition (lpGrigliaStruct);
  401.             }
  402.             break;
  403.  
  404.         case VK_DOWN:
  405.             if (MoveCursorDown (lpGrigliaStruct)) {
  406.                 FireChangeEvent (hctl, wOldRow, wOldCol, NULL);
  407.  
  408.                 if (lpGrigliaStruct->wEnableEdit == ERASE_FLAG)
  409.                     DisplayPosition (lpGrigliaStruct);
  410.             }
  411.             break;
  412.  
  413.         case VK_SHIFT:
  414.             bShiftPressed = FALSE;
  415.             break;
  416.  
  417.         case VK_CONTROL:
  418.             bCtrlPressed = FALSE;
  419.             break;
  420.  
  421.         case VK_F2:
  422.             if (
  423.                 (lpGrigliaStruct->wEnableEdit != ERASE_FLAG)         &&
  424.                 (lpGrigliaStruct->wEnableEdit != ERASE_DISABLE_FLAG)
  425.                ) {
  426.                 int nLen;
  427.  
  428.                 nLen = GetWindowTextLength (lpGrigliaStruct->hWndEdit);
  429.                 SendMessage (lpGrigliaStruct->hWndEdit,
  430.                             EM_SETSEL,     NULL,
  431.                             MAKELONG (nLen, nLen));
  432.  
  433.                 PostMessage (lpGrigliaStruct->hWndEdit,
  434.                             WM_ACTIVATE, 1, MAKELONG (0, hWnd));
  435.  
  436.                 // INTO EDIT MODE
  437.                 lpGrigliaStruct->lStatus |= EDIT_FLAG;
  438.             }
  439.             break;
  440.  
  441.     }
  442.     nRepeatKey = 0;
  443.     return;
  444. }
  445.  
  446. //---------------------------------------------------------------------------
  447. // KeyDown
  448. //---------------------------------------------------------------------------
  449. void KeyDown (HCTL   hctl,
  450.               HWND   hWnd,
  451.               WORD   wp) {
  452.  
  453.     WORD wOldRow, wOldCol, wOldRepeatKey;
  454.     PGRIGLIA    lpGrigliaStruct = GRIGLIADEREF(hctl);
  455.  
  456.     wOldRow    = lpGrigliaStruct->wCursorRow;
  457.     wOldCol    = lpGrigliaStruct->wCursorCol;
  458.     wOldRepeatKey = nRepeatKey;
  459.  
  460.     if (lpGrigliaStruct->lStatus & EDIT_FLAG)
  461.         return;
  462.  
  463.     switch (wp) {
  464.         case VK_SHIFT:
  465.                 bShiftPressed = TRUE;
  466.                 break;
  467.  
  468.         case VK_CONTROL:
  469.                 bCtrlPressed = TRUE;
  470.                 break;
  471.  
  472.         case VK_PRIOR:
  473.             ++nRepeatKey;
  474.             for (; nRepeatKey > 1; --nRepeatKey)
  475.                 MoveCursorPrior (lpGrigliaStruct, bCtrlPressed);
  476.             if (wOldRepeatKey)
  477.                 FireChangeEvent (hctl, wOldRow, wOldCol, NULL);
  478.  
  479.             if (lpGrigliaStruct->wEnableEdit == ERASE_FLAG)
  480.                 DisplayPosition (lpGrigliaStruct);
  481.             break;
  482.  
  483.         case VK_NEXT:
  484.             ++nRepeatKey;
  485.             for (; nRepeatKey > 1; --nRepeatKey)
  486.                 MoveCursorNext (lpGrigliaStruct, bCtrlPressed);
  487.             if (wOldRepeatKey)
  488.                 FireChangeEvent (hctl, wOldRow, wOldCol, NULL);
  489.  
  490.             if (lpGrigliaStruct->wEnableEdit == ERASE_FLAG)
  491.                 DisplayPosition (lpGrigliaStruct);
  492.             break;
  493.  
  494.         case VK_LEFT:
  495.             ++nRepeatKey;
  496.             for (; nRepeatKey > 1; --nRepeatKey)
  497.                 MoveCursorLeft (lpGrigliaStruct);
  498.             if (wOldRepeatKey)
  499.                 FireChangeEvent (hctl, wOldRow, wOldCol, NULL);
  500.  
  501.             if (lpGrigliaStruct->wEnableEdit == ERASE_FLAG)
  502.                 DisplayPosition (lpGrigliaStruct);
  503.             break;
  504.  
  505.         case VK_RIGHT:
  506.             ++nRepeatKey;
  507.             for (; nRepeatKey > 1; --nRepeatKey)
  508.                 MoveCursorRight (lpGrigliaStruct);
  509.             if (wOldRepeatKey)
  510.                 FireChangeEvent (hctl, wOldRow, wOldCol, NULL);
  511.  
  512.             if (lpGrigliaStruct->wEnableEdit == ERASE_FLAG)
  513.                 DisplayPosition (lpGrigliaStruct);
  514.             break;
  515.  
  516.         case VK_UP:
  517.             ++nRepeatKey;
  518.             for (; nRepeatKey > 1; --nRepeatKey)
  519.                 MoveCursorUp (lpGrigliaStruct);
  520.             if (wOldRepeatKey)
  521.                 FireChangeEvent (hctl, wOldRow, wOldCol, NULL);
  522.  
  523.             if (lpGrigliaStruct->wEnableEdit == ERASE_FLAG)
  524.                 DisplayPosition (lpGrigliaStruct);
  525.             break;
  526.  
  527.         case VK_DOWN:
  528.             ++nRepeatKey;
  529.             for (; nRepeatKey > 1; --nRepeatKey)
  530.                 MoveCursorDown (lpGrigliaStruct);
  531.             if (wOldRepeatKey)
  532.                 FireChangeEvent (hctl, wOldRow, wOldCol, NULL);
  533.  
  534.             if (lpGrigliaStruct->wEnableEdit == ERASE_FLAG)
  535.                 DisplayPosition (lpGrigliaStruct);
  536.             break;
  537.     }
  538.     return;
  539. }
  540.  
  541. //---------------------------------------------------------------------------
  542. // Wm_Character
  543. //---------------------------------------------------------------------------
  544. void Wm_Character (HCTL   hctl,
  545.                    HWND   hWnd,
  546.                    WORD   wp) {
  547.  
  548.     PGRIGLIA    lpGrigliaStruct = GRIGLIADEREF(hctl);
  549.     switch (wp) {
  550.  
  551.         case VK_ESCAPE:
  552.             if (
  553.                 ((lpGrigliaStruct->lpHorBars + lpGrigliaStruct->wCursorRow)->wStatus == ENABLE_FLAG) &&
  554.                 ((lpGrigliaStruct->lpVertBars + lpGrigliaStruct->wCursorCol)->wStatus == ENABLE_FLAG) &&
  555.                 (lpGrigliaStruct->wEnableEdit == ENABLE_FLAG)
  556.                ) {
  557.                 
  558.                 LPSTR lpStr;
  559.  
  560.                 if (lpStr = GetCellText (lpGrigliaStruct,
  561.                                          lpGrigliaStruct->wCursorRow,
  562.                                          lpGrigliaStruct->wCursorCol)) {
  563.                     PostMessage (lpGrigliaStruct->hWndEdit,
  564.                                  WM_SETTEXT, NULL,
  565.                                  (LONG)lpStr);
  566.                     SetCellText (lpGrigliaStruct,
  567.                                  lpGrigliaStruct->wCursorRow,
  568.                                  lpGrigliaStruct->wCursorCol,
  569.                                  lpStr);
  570.                 } else {
  571.  
  572.                     PostMessage (lpGrigliaStruct->hWndEdit,
  573.                                  WM_SETTEXT, NULL,
  574.                                  (LONG)(LPSTR)"");
  575.                     SetCellText (lpGrigliaStruct,
  576.                                  lpGrigliaStruct->wCursorRow,
  577.                                  lpGrigliaStruct->wCursorCol,
  578.                                  "");
  579.                 }
  580.  
  581.                 PostMessage (lpGrigliaStruct->hWndEdit,
  582.                             WM_ACTIVATE, 1, MAKELONG (0, hWnd));
  583.                 PostMessage (lpGrigliaStruct->hWndEdit,
  584.                              EM_SETSEL,  NULL,
  585.                              MAKELONG(0, -1));
  586.  
  587.                 // OFF EDIT MODE
  588.                 lpGrigliaStruct->lStatus &= RES_EDIT_FLAG;
  589.             }
  590.             break;
  591.  
  592.         case VK_RETURN:
  593.                     
  594.             if (
  595.                 ((lpGrigliaStruct->lpHorBars + lpGrigliaStruct->wCursorRow)->wStatus == ENABLE_FLAG) &&
  596.                 ((lpGrigliaStruct->lpVertBars + lpGrigliaStruct->wCursorCol)->wStatus == ENABLE_FLAG) &&
  597.                 (lpGrigliaStruct->wEnableEdit == ENABLE_FLAG)
  598.                ) {
  599.                 
  600.                 HANDLE hOldText;
  601.                 PSTR   pOldStr;
  602.                 LPSTR  lpOldpStr;
  603.                 HANDLE hText;
  604.                 PSTR   pStr;
  605.                 SHORT  nLen;
  606.  
  607.                 // retrieve previous text value
  608.                 lpOldpStr = GetCellText (lpGrigliaStruct,
  609.                                          lpGrigliaStruct->wCursorRow,
  610.                                          lpGrigliaStruct->wCursorCol);
  611.  
  612.                 // get its size
  613.                 nLen = 0;
  614.                 if (lpOldpStr)
  615.                     nLen = lstrlen (lpOldpStr);
  616.  
  617.                 // try to store it
  618.                 if ( hOldText = LocalAlloc ( LHND, nLen + 3)) {
  619.                     pOldStr = (PSTR) LocalLock (hOldText);
  620.                     if (lpOldpStr)
  621.                         lstrcpy (pOldStr, lpOldpStr);
  622.                     else
  623.                         lstrcpy (pOldStr, "");
  624.                 } else {
  625.                     hOldText = NULL;
  626.                     pOldStr  = (PSTR)NULL;
  627.                 }
  628.  
  629.                 // change text
  630.                 nLen = GetWindowTextLength (lpGrigliaStruct->hWndEdit);
  631.                 if ( hText = LocalAlloc ( LHND,
  632.                                           nLen + 3) ) {
  633.                     pStr = (PSTR) LocalLock (hText);
  634.                     GetWindowText (lpGrigliaStruct->hWndEdit, (LPSTR)pStr, nLen + 1);
  635.  
  636.                     if (PutCellText (lpGrigliaStruct,
  637.                                      lpGrigliaStruct->wCursorRow,
  638.                                      lpGrigliaStruct->wCursorCol,
  639.                                      (LPSTR)pStr)) {
  640.                         SetCellText (lpGrigliaStruct,
  641.                                      lpGrigliaStruct->wCursorRow,
  642.                                      lpGrigliaStruct->wCursorCol,
  643.                                      pStr);
  644.                         if (pOldStr)
  645.                             FireChangeEvent (hctl,
  646.                                              lpGrigliaStruct->wCursorRow,
  647.                                              lpGrigliaStruct->wCursorCol,
  648.                                              (LPSTR)pOldStr
  649.                                             );
  650.                         else
  651.                             FireChangeEvent (hctl,
  652.                                              lpGrigliaStruct->wCursorRow,
  653.                                              lpGrigliaStruct->wCursorCol,
  654.                                              (LPSTR)""
  655.                                             );
  656.                     }
  657.                     LocalUnlock (hText);
  658.                     LocalFree (hText);
  659.                     if (hOldText) {
  660.                         LocalUnlock (hOldText);
  661.                         LocalFree (hOldText);
  662.                     }
  663.                 }
  664.  
  665.                 // OFF EDIT MODE
  666.                 PostMessage (lpGrigliaStruct->hWndEdit,
  667.                             WM_ACTIVATE, 1, MAKELONG (0, hWnd));
  668.                 SendMessage (lpGrigliaStruct->hWndEdit,
  669.                              EM_SETSEL,  NULL,
  670.                              MAKELONG(0, -1));
  671.                 lpGrigliaStruct->lStatus &= RES_EDIT_FLAG;
  672.  
  673.             }
  674.             break;
  675.  
  676.         default:
  677.             if (lpGrigliaStruct->wEnableEdit == ERASE_DISABLE_FLAG)
  678.                 break;
  679.             else if (lpGrigliaStruct->wEnableEdit != ERASE_FLAG) {
  680.                 static szStr [2];
  681.  
  682.                 PostMessage (lpGrigliaStruct->hWndEdit,
  683.                             WM_ACTIVATE, 1, MAKELONG (0, hWnd));
  684.                 szStr [0] = wp;
  685.                 szStr [1] = 0;
  686.                 PostMessage (lpGrigliaStruct->hWndEdit,
  687.                             WM_SETTEXT, NULL, (LONG)(LPSTR)&szStr[0]);
  688.                 PostMessage (lpGrigliaStruct->hWndEdit,
  689.                             EM_SETSEL, NULL, MAKELONG (1, 1));
  690.             } else if (
  691.                        ((lpGrigliaStruct->lpHorBars +
  692.                          lpGrigliaStruct->wCursorRow)->wStatus == ENABLE_FLAG)  &&
  693.                        ((lpGrigliaStruct->lpVertBars +
  694.                          lpGrigliaStruct->wCursorCol)->wStatus == ENABLE_FLAG)
  695.                       ) {
  696.                 LPSTR  lpStr;
  697.                 PSTR   pStr;
  698.                 HANDLE hText;
  699.                 UINT   nLen;
  700.                 // retrieve previous text value
  701.                 lpStr = GetCellText (lpGrigliaStruct,
  702.                                      lpGrigliaStruct->wCursorRow,
  703.                                      lpGrigliaStruct->wCursorCol);
  704.  
  705.                 // get its size
  706.                 nLen = 0;
  707.                 if (lpStr)
  708.                     nLen = _fstrlen (lpStr);
  709.  
  710.                 // try to store it
  711.                 if ( hText = LocalAlloc ( LHND, nLen + 3)) {
  712.                     pStr = (PSTR) LocalLock (hText);
  713.                     if (
  714.                         (lpStr) &&
  715.                         (nLen)
  716.                        )
  717.                         _fstrcpy (pStr, lpStr);
  718.                     else
  719.                         _fstrcpy (pStr, "");
  720.  
  721.                     if (wp == VK_BACK) {
  722.                         if (nLen)
  723.                             *(pStr + nLen - 1) = 0;
  724.                     } else if (isprint (wp)) {
  725.                         // add new char
  726.                         *(pStr + nLen)     = LOBYTE (wp);
  727.                         *(pStr + nLen + 1) = 0;
  728.                     }
  729.                     if (PutCellText (lpGrigliaStruct,
  730.                                      lpGrigliaStruct->wCursorRow,
  731.                                      lpGrigliaStruct->wCursorCol,
  732.                                      (LPSTR)pStr)) {
  733.                         DestroyCaret ();
  734.                         SetCellText (lpGrigliaStruct,
  735.                                      lpGrigliaStruct->wCursorRow,
  736.                                      lpGrigliaStruct->wCursorCol,
  737.                                      pStr);
  738.                         DisplayPosition (lpGrigliaStruct);
  739.                     }
  740.                     LocalUnlock (hText);
  741.                     LocalFree (hText);
  742.                 }
  743.             }
  744.             break;
  745.     }
  746. }
  747.  
  748. //---------------------------------------------------------------------------
  749. // DisplayPosition
  750. //---------------------------------------------------------------------------
  751. void DisplayPosition (PGRIGLIA lpGrigliaStruct) {
  752.  
  753.            LPSTR lpStr;
  754.            HDC   hDC;
  755.            SHORT nXLen, nYLen;
  756.     static RECT  rCell;
  757.  
  758.     if (hDC = GetDC (lpGrigliaStruct->hWndStatic)) {
  759.  
  760.         lpStr = GetCellText (lpGrigliaStruct,
  761.                              lpGrigliaStruct->wCursorRow,
  762.                              lpGrigliaStruct->wCursorCol);
  763.         if (
  764.             (lpStr) &&
  765.             (_fstrlen (lpStr))
  766.            ) {
  767.             nXLen = LOWORD (GetTextExtent (hDC, lpStr, _fstrlen (lpStr)));
  768.             nYLen = max (HIWORD (GetTextExtent (hDC, lpStr,
  769.                                                 _fstrlen (lpStr))) - 4,
  770.                          4);
  771.         } else {
  772.             nXLen = 3;
  773.             nYLen = max (HIWORD (GetTextExtent (hDC, "A", 1)) - 4, 4);
  774.         }
  775.         ReleaseDC(lpGrigliaStruct->hWndStatic, hDC);
  776.  
  777.         CreateCaret (lpGrigliaStruct->hWndStatic,
  778.                      0, 1, nYLen);
  779.         if (
  780.             (CellRect (lpGrigliaStruct,
  781.                       lpGrigliaStruct->wCursorCol,
  782.                       lpGrigliaStruct->wCursorRow,
  783.                       (LPRECT)&rCell))                                  &&
  784.             ((lpGrigliaStruct->lpHorBars +
  785.                 lpGrigliaStruct->wCursorRow)->wStatus == ENABLE_FLAG)   &&
  786.             ((lpGrigliaStruct->lpVertBars +
  787.                 lpGrigliaStruct->wCursorCol)->wStatus == ENABLE_FLAG)   &&
  788.             (rCell.left + nXLen <= rCell.right)
  789.            ) {
  790.             SetCaretPos (rCell.left + nXLen, rCell.top + 4);
  791.             ShowCaret   (NULL);
  792.         }
  793.     }
  794. }
  795.